home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / m2 / cat3src / magic / i / magicxbi.i < prev    next >
Encoding:
Modula Implementation  |  1997-10-26  |  15.4 KB  |  996 lines
  1. (*----------------------------------------------------------------------*
  2.  *                                                                      *
  3.  *         MAGIC   Modula's  All purpose  GEM  Interface  Cadre         *
  4.  *                 ÿ         ÿ            ÿ    ÿ          ÿ             *
  5.  *----------------------------------------------------------------------*
  6.  * Version 3.30  02.02.1992     (C)90/91/92 by Peter Hellinger Software *
  7.  *----------------------------------------------------------------------*
  8.  *            Dieses Modul ist urheberrechtlich geschtzt.              *
  9.  *                                                                      *
  10.  * Die Ver”ffentlichung des Quelltextes oder Teilen daraus in schrift-  *
  11.  * licher Form, insbesondere in Zeitschriften, sowie die Verbreitung    *
  12.  * ber Public-Domain-H„ndler bedarf der ausdrcklichen schriftlichen   *
  13.  * Genehmigung des Autors!                                              *
  14.  *                                                                      *
  15.  * Der Autor gibt hiermit die ausdrckliche Erlaubnis, das Modul jeder- *
  16.  * zeit auch im Quelltext weiterzugegeben, sofern dessen Text und ins-  *
  17.  * besondere dieser Urheberrechts-Vermerk nicht ver„ndert wird, und     *
  18.  * durch die Weitergabe kein finanzieller Nutzen entsteht. Der Autor    *
  19.  * beh„lt sich das Recht vor, diese Erlaubnis jederzeit u. ohne Angaben *
  20.  * von Grnden zu widerrufen.                                           *
  21.  *----------------------------------------------------------------------*)
  22.  
  23. IMPLEMENTATION MODULE MagicXBIOS;
  24.  
  25. (*----------------------------------------------------------------------*
  26.  * Int. Vers | Datum    | Name | Žnderung                               *
  27.  *-----------+----------+------+----------------------------------------*
  28.  *  3.00     | 18.01.92 |  Hp  |                                        *
  29.  *-----------+----------+------+----------------------------------------*)
  30.  
  31.  
  32.  
  33. (* IMPLEMENTATION FšR  >>> Megamax-Modula-2 <<< *)
  34. (*                                              *)
  35. (*$R-   Range-Checks                            *)
  36. (*$S-   Stack-Check                             *)
  37. (*                                              *)
  38. (*----------------------------------------------*)
  39.  
  40.  
  41.  
  42.  
  43.  
  44.  
  45. FROM MagicSys   IMPORT  Nil, Null, Bit0, Bit1, Bit2, Bit3, Bit4, Bit5, Bit6,
  46.                         Bit7, Bit8, Bit9, Bit10, Bit11, Bit12, Bit13, Bit14,
  47.                         Bit15, LOC, Byte, ByteSet, sWORD, sINTEGER, sCARDINAL,
  48.                         sBITSET, lINTEGER, lCARDINAL, lWORD, lBITSET,
  49.                         CastToChar, CastToByte, CastToByteset, CastToInt,
  50.                         CastToCard, CastToBitset, CastToWord, CastToLInt,
  51.                         CastToLCard, CastToLBitset, CastToLWord, CastToAddr,
  52.                         TosVersion, Accessory, Basepage, SysHeader, TosDate;
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59. FROM SYSTEM IMPORT ADDRESS, ADR, WORD, BYTE;
  60. IMPORT MagicSys;
  61.  
  62.  
  63. FROM SYSTEM IMPORT ASSEMBLER;
  64. VAR c: sCARDINAL;
  65.     i: sINTEGER;
  66.     l: lINTEGER;
  67.  
  68.  
  69.  
  70.  
  71.  
  72. VAR a, b, d: ADDRESS;
  73.  
  74. PROCEDURE Initmouse (type: sINTEGER; VAR param: ARRAY OF LOC; vec: PROC);
  75. VAR a: ADDRESS;
  76. BEGIN
  77.  
  78.  ASSEMBLER
  79.   MOVE.L  vec(A6), -(SP)
  80.   MOVE.L  param(A6), -(SP)
  81.   MOVE.W  type(A6), -(SP)
  82.   MOVE.W  #0, -(SP);
  83.   TRAP    #14
  84.   LEA     12(SP), SP
  85.  END;
  86.  
  87.  
  88.  
  89.  
  90. END Initmouse;
  91.  
  92. PROCEDURE Physbase (): ADDRESS;
  93. BEGIN
  94.  
  95.  ASSEMBLER
  96.   MOVE.W  #2, -(SP);
  97.   TRAP    #14
  98.   ADDQ.L  #2, SP
  99.   MOVE.L  D0, a
  100.  END;
  101.  RETURN a;
  102.  
  103.  
  104.  
  105.  
  106. END Physbase;
  107.  
  108. PROCEDURE Logbase (): ADDRESS;
  109. BEGIN
  110.  
  111.  ASSEMBLER
  112.   MOVE.W  #3, -(SP);
  113.   TRAP    #14
  114.   ADDQ.L  #2, SP
  115.   MOVE.L  D0, a
  116.  END;
  117.  RETURN a;
  118.  
  119.  
  120.  
  121.  
  122. END Logbase;
  123.  
  124. PROCEDURE Getrez (): sINTEGER;
  125. BEGIN
  126.  
  127.  ASSEMBLER
  128.   MOVE.W  #4, -(SP);
  129.   TRAP    #14
  130.   ADDQ.L  #2, SP
  131.   MOVE.W  D0, i
  132.  END;
  133.  RETURN i;
  134.  
  135.  
  136.  
  137.  
  138. END Getrez;
  139.  
  140. PROCEDURE Setscreen (log, phys: ADDRESS; rez: sINTEGER);
  141. BEGIN
  142.  
  143.  ASSEMBLER
  144.   MOVE.W  rez(A6), -(SP)
  145.   MOVE.L  phys(A6), -(SP)
  146.   MOVE.L  log(A6), -(SP)
  147.   MOVE.W  #5, -(SP)
  148.   TRAP    #14
  149.   LEA     $C(SP), SP
  150.  END;
  151.  
  152.  
  153.  
  154.  
  155. END Setscreen;
  156.  
  157. PROCEDURE Setpalette (VAR palette: ARRAY OF LOC);
  158. BEGIN
  159.  
  160.  ASSEMBLER
  161.   MOVE.L  palette(A6), -(SP)
  162.   MOVE.W  #6, -(SP)
  163.   TRAP    #14
  164.   ADDQ.L  #6, SP
  165.  END;
  166.  
  167.  
  168.  
  169.  
  170. END Setpalette;
  171.  
  172. PROCEDURE Setcolor (colNum, color: sCARDINAL): sCARDINAL;
  173. VAR c: sCARDINAL;
  174. BEGIN
  175.  
  176.  ASSEMBLER
  177.   MOVE.W  color(A6), -(SP)
  178.   MOVE.W  colNum(A6), -(SP)
  179.   MOVE.W  #7, -(SP)
  180.   TRAP    #14
  181.   ADDQ.L  #6, SP
  182.   MOVE.W  D0, c(A6)
  183.  END;
  184.  RETURN c;
  185.  
  186.  
  187.  
  188.  
  189. END Setcolor;
  190.  
  191. PROCEDURE Floprd (buf: ADDRESS; drv, sec, trck, side, count: sINTEGER): sINTEGER;
  192. VAR i: sINTEGER;
  193. BEGIN
  194.  
  195.  ASSEMBLER
  196.   MOVE.W  count(A6), -(SP)
  197.   MOVE.W  side(A6), -(SP)
  198.   MOVE.W  trck(A6), -(SP)
  199.   MOVE.W  sec(A6), -(SP)
  200.   MOVE.W  drv(A6), -(SP)
  201.   MOVE.L  #0, -(SP)
  202.   MOVE.L  buf(A6), -(SP)
  203.   MOVE.W  #8, -(SP)
  204.   TRAP    #14
  205.   LEA     $14(SP), SP
  206.   MOVE.W  D0, i(A6)
  207.  END;
  208.  RETURN i;
  209.  
  210.  
  211.  
  212.  
  213. END Floprd;
  214.  
  215. PROCEDURE Flopwr (buf: ADDRESS; drv, sec, trck, side, count: sINTEGER): sINTEGER;
  216. VAR i: sINTEGER;
  217. BEGIN
  218.  
  219.  ASSEMBLER
  220.   MOVE.W  count(A6), -(SP)
  221.   MOVE.W  side(A6), -(SP)
  222.   MOVE.W  trck(A6), -(SP)
  223.   MOVE.W  sec(A6), -(SP)
  224.   MOVE.W  drv(A6), -(SP)
  225.   MOVE.L  #0, -(SP)
  226.   MOVE.L  buf(A6), -(SP)
  227.   MOVE.W  #9, -(SP)
  228.   TRAP    #14
  229.   LEA     $14(SP), SP
  230.   MOVE.W  D0, i(A6)
  231.  END;
  232.  RETURN i;
  233.  
  234.  
  235.  
  236.  
  237. END Flopwr;
  238.  
  239. PROCEDURE Flopfmt (buf: ADDRESS; drv, spt, trck, side, il, virgin: sINTEGER): sINTEGER;
  240. VAR i: sINTEGER;
  241. BEGIN
  242.  
  243.  ASSEMBLER
  244.   MOVE.W  virgin(A6), -(SP)
  245.   MOVE.L  #$087654321, -(SP)
  246.   MOVE.W  il(A6), -(SP)
  247.   MOVE.W  side(A6), -(SP)
  248.   MOVE.W  trck(A6), -(SP)
  249.   MOVE.W  spt(A6), -(SP)
  250.   MOVE.W  drv(A6), -(SP)
  251.   MOVE.L  #0, -(SP)
  252.   MOVE.L  buf(A6), -(SP)
  253.   MOVE.W  #10, -(SP)
  254.   TRAP    #14
  255.   LEA     $1A(SP), SP
  256.   MOVE.W  D0, i(A6)
  257.  END;
  258.  RETURN i;
  259.  
  260.  
  261.  
  262.  
  263. END Flopfmt;
  264.  
  265. PROCEDURE Midiws (VAR string: ARRAY OF LOC; len: sCARDINAL);
  266. BEGIN
  267.  
  268.  ASSEMBLER
  269.   MOVE.L  string(A6), -(SP)
  270.   MOVE.W  len(A6), -(SP)
  271.   MOVE.W  #12, -(SP)
  272.   TRAP    #14
  273.   ADDQ.L  #8, SP
  274.  END;
  275.  
  276.  
  277.  
  278.  
  279. END Midiws;
  280.  
  281. PROCEDURE Mfpint (intNo: sCARDINAL; vector: PROC);
  282. VAR x: ADDRESS;
  283. BEGIN
  284.  
  285.  ASSEMBLER
  286.   MOVE.L  vector(A6), -(SP)
  287.   MOVE.W  intNo(A6), -(SP)
  288.   MOVE.W  #13, -(SP)
  289.   TRAP    #14
  290.   ADDQ.L  #8, SP
  291.  END;
  292.  
  293.  
  294.  
  295.  
  296. END Mfpint;
  297.  
  298. PROCEDURE Iorec (dev: sINTEGER): ADDRESS;
  299. VAR a: ADDRESS;
  300. BEGIN
  301.  
  302.  ASSEMBLER
  303.   MOVE.W  dev(A6), -(SP)
  304.   MOVE.W  #14, -(SP)
  305.   TRAP    #14
  306.   ADDQ.L  #4, SP
  307.   MOVE.L  D0, a(A6)
  308.  END;
  309.  RETURN a;
  310.  
  311.  
  312.  
  313.  
  314. END Iorec;
  315.  
  316. PROCEDURE Rsconf (speed: sINTEGER; flavor: sBITSET;  u, r, t, s: sINTEGER): sINTEGER;
  317. VAR i: sINTEGER;
  318. BEGIN
  319.  
  320.  ASSEMBLER
  321.   MOVE.W  s(A6), -(SP)
  322.   MOVE.W  t(A6), -(SP)
  323.   MOVE.W  r(A6), -(SP)
  324.   MOVE.W  u(A6), -(SP)
  325.   MOVE.W  flavor(A6), -(SP)
  326.   MOVE.W  speed(A6), -(SP)
  327.   MOVE.W  #15, -(SP)
  328.   TRAP    #14
  329.   LEA     $E(SP), SP
  330.   MOVE.W  D0, i(A6)
  331.  END;
  332.  RETURN i;
  333.  
  334.  
  335.  
  336.  
  337. END Rsconf;
  338.  
  339. PROCEDURE Keytbl (VAR unshift, shift, capslock: ADDRESS): ADDRESS;
  340. BEGIN
  341.  
  342.  a:= unshift;
  343.  b:= shift;
  344.  d:= capslock;
  345.  ASSEMBLER
  346.   MOVE.L  a, -(SP)
  347.   MOVE.L  b, -(SP)
  348.   MOVE.L  d, -(SP)
  349.   MOVE.W  #16, -(SP)
  350.   TRAP    #14
  351.   LEA     $E(SP), SP
  352.   MOVE.L  D0, a
  353.  END;
  354.  RETURN a;
  355.  
  356.  
  357.  
  358.  
  359. END Keytbl;
  360.  
  361. PROCEDURE Random(): lCARDINAL;
  362. VAR l: lCARDINAL;
  363. BEGIN
  364.  
  365.  ASSEMBLER
  366.   MOVE.W  #17, -(SP)
  367.   TRAP    #14
  368.   ADDQ.L  #2, SP
  369.   MOVE.L  D0, l(A6)
  370.  END;
  371.  RETURN l;
  372.  
  373.  
  374.  
  375.  
  376. END Random;
  377.  
  378. PROCEDURE Protobt (buf: ADDRESS; num: lINTEGER; typ, exec: sINTEGER);
  379. BEGIN
  380.  
  381.  ASSEMBLER
  382.   MOVE.W  exec(A6), -(SP)
  383.   MOVE.W  typ(A6), -(SP)
  384.   MOVE.L  num(A6), -(SP)
  385.   MOVE.L  buf(A6), -(SP)
  386.   MOVE.W  #18, -(SP)
  387.   TRAP    #14
  388.   LEA     $E(SP), SP
  389.  END;
  390.  
  391.  
  392.  
  393.  
  394. END Protobt;
  395.  
  396. PROCEDURE Flopver (buf: ADDRESS; drv, sec, trck, side, count: sINTEGER): sINTEGER;
  397. VAR i: sINTEGER;
  398. BEGIN
  399.  
  400.  ASSEMBLER
  401.   MOVE.W  count(A6), -(SP)
  402.   MOVE.W  side(A6), -(SP)
  403.   MOVE.W  trck(A6), -(SP)
  404.   MOVE.W  sec(A6), -(SP)
  405.   MOVE.W  drv(A6), -(SP)
  406.   MOVE.L  #0, -(SP)
  407.   MOVE.L  buf(A6), -(SP)
  408.   MOVE.W  #19, -(SP)
  409.   TRAP    #14
  410.   LEA     $E(SP), SP
  411.   MOVE.W  D0, i(A6)
  412.  END;
  413.  RETURN i;
  414.  
  415.  
  416.  
  417.  
  418. END Flopver;
  419.  
  420. PROCEDURE Scrdmp;
  421. BEGIN
  422.  
  423.  ASSEMBLER
  424.   MOVE.W  #20, -(SP)
  425.   TRAP    #14
  426.   ADDQ.L  #2, SP
  427.  END;
  428.  
  429.  
  430.  
  431.  
  432. END Scrdmp;
  433.  
  434. PROCEDURE Cursconf (function, operand: sINTEGER): sINTEGER;
  435. VAR i: sINTEGER;
  436. BEGIN
  437.  
  438.  ASSEMBLER
  439.   MOVE.W  operand(A6), -(SP)
  440.   MOVE.W  function(A6), -(SP)
  441.   MOVE.W  #21, -(SP)
  442.   TRAP    #14
  443.   ADDQ.L  #6, SP
  444.   MOVE.W  D0, i(A6)
  445.  END;
  446.  RETURN i;
  447.  
  448.  
  449.  
  450.  
  451. END Cursconf;
  452.  
  453. PROCEDURE Settime (datetime: lCARDINAL);
  454. BEGIN
  455.  
  456.  ASSEMBLER
  457.   MOVE.W  datetime(A6), -(SP)
  458.   MOVE.W  #22, -(SP)
  459.   TRAP    #14
  460.   ADDQ.L  #6, SP
  461.  END;
  462.  
  463.  
  464.  
  465.  
  466. END Settime;
  467.  
  468. PROCEDURE Gettime (): lCARDINAL;
  469. VAR l: lCARDINAL;
  470. BEGIN
  471.  
  472.  ASSEMBLER
  473.   MOVE.W    #23, -(SP)
  474.   TRAP    #14
  475.   ADDQ.L  #2, SP
  476.   MOVE.L  D0, l(A6)
  477.  END; 
  478.  RETURN l;
  479.  
  480.  
  481.  
  482.  
  483. END Gettime;
  484.  
  485. PROCEDURE Bioskeys;
  486. BEGIN
  487.  
  488.  ASSEMBLER
  489.   MOVE.W  #24, -(SP)
  490.   TRAP    #14
  491.   ADDQ.L  #2, SP
  492.  END;
  493.  
  494.  
  495.  
  496.  
  497. END Bioskeys;
  498.  
  499. PROCEDURE Ikbdws (str: ARRAY OF LOC; len: sCARDINAL);
  500. BEGIN
  501.  
  502.  ASSEMBLER
  503.   MOVE.L  str(A6), -(SP)
  504.   MOVE.W  len(A6), -(SP)
  505.   MOVE.W  #25, -(SP)
  506.   TRAP    #14
  507.   ADDQ.L  #8, SP
  508.  END; 
  509.  
  510.  
  511.  
  512.  
  513. END Ikbdws;
  514.  
  515. PROCEDURE Jdisint (intNo: sCARDINAL);
  516. BEGIN
  517.  
  518.  ASSEMBLER
  519.   MOVE.W  intNo(A6), -(SP)
  520.   MOVE.W  #26, -(SP)
  521.   TRAP    #14
  522.   ADDQ.L  #4, SP
  523.  END;
  524.  
  525.  
  526.  
  527.  
  528. END Jdisint;
  529.  
  530. PROCEDURE Jenabint (intNo: sCARDINAL);
  531. BEGIN
  532.  
  533.  ASSEMBLER
  534.   MOVE.W  intNo(A6), -(SP)
  535.   MOVE.W  #27, -(SP)
  536.   TRAP    #14
  537.   ADDQ.L  #4, SP
  538.  END;
  539.  
  540.  
  541.  
  542.  
  543. END Jenabint;
  544.  
  545. PROCEDURE Giaccess (regno: sCARDINAL; data: Byte): sCARDINAL;
  546. VAR c: sCARDINAL;
  547. BEGIN
  548.  
  549.  c:= ORD (data);
  550.  ASSEMBLER
  551.   MOVE.W  regno(A6), -(SP)
  552.   MOVE.W  c(A6), -(SP)
  553.   MOVE.W  #28, -(SP)
  554.   TRAP    #14
  555.   ADDQ.L  #6, SP
  556.   MOVE.W  D0, c(A6)
  557.  END;
  558.  RETURN c;
  559.  
  560.  
  561.  
  562.  
  563. END Giaccess;
  564.  
  565. PROCEDURE Offgibit (bitno: sCARDINAL);
  566. BEGIN
  567.  
  568.  ASSEMBLER
  569.   MOVE.W  bitno(A6), -(SP)
  570.   MOVE.W  #29, -(SP)
  571.   TRAP    #14
  572.   ADDQ.L  #4, SP
  573.  END;
  574.  
  575.  
  576.  
  577.  
  578. END Offgibit;
  579.  
  580. PROCEDURE Ongibit (bitno: sCARDINAL);
  581. BEGIN
  582.  
  583.  ASSEMBLER
  584.   MOVE.W  bitno(A6), -(SP)
  585.   MOVE.W  #30, -(SP)
  586.   TRAP    #14
  587.   ADDQ.L  #4, SP
  588.  END;
  589.  
  590.  
  591.  
  592.  
  593. END Ongibit;
  594.  
  595. PROCEDURE Xbtimer (timer, control, data: sCARDINAL; vec: PROC);
  596. BEGIN
  597.  
  598.  ASSEMBLER
  599.   MOVE.L  vec(A6), -(SP)
  600.   MOVE.W  data(A6), -(SP)
  601.   MOVE.W  control(A6), -(SP)
  602.   MOVE.W  timer(A6), -(SP)
  603.   MOVE.W  #31, -(SP)
  604.   TRAP    #14
  605.   LEA     $C(SP), SP
  606.  END;
  607.  
  608.  
  609.  
  610.  
  611. END Xbtimer;
  612.  
  613. PROCEDURE Dosound (REF data: ARRAY OF LOC);
  614. BEGIN
  615.  
  616.  ASSEMBLER
  617.   MOVE.L  data(A6), -(SP)
  618.   MOVE.W  #32, -(SP)
  619.   TRAP    #14
  620.   ADDQ.L  #6, SP
  621.  END;
  622.  
  623.  
  624.  
  625.  
  626. END Dosound;
  627.  
  628. PROCEDURE Setprt (config: sBITSET): sBITSET;
  629. VAR b: sBITSET;
  630. BEGIN
  631.  
  632.  ASSEMBLER
  633.   MOVE.W  config(A6), -(SP)
  634.   MOVE.W  #33, -(SP)
  635.   TRAP    #14
  636.   ADDQ.L  #6, SP
  637.   MOVE.W  D0, b(A6)
  638.  END;
  639.  RETURN b;
  640.  
  641.  
  642.  
  643.  
  644. END Setprt;
  645.  
  646. PROCEDURE Kbdvbase(): ADDRESS;
  647. VAR a: ADDRESS;
  648. BEGIN
  649.  
  650.  ASSEMBLER
  651.   MOVE.W  #34, -(SP)
  652.   TRAP    #14
  653.   ADDQ.L  #2, SP
  654.   MOVE.L  D0, a(A6)
  655.  END;
  656.  RETURN a;
  657.  
  658.  
  659.  
  660.  
  661. END Kbdvbase;
  662.  
  663. PROCEDURE Kbrate (initial, repeat: sINTEGER): sCARDINAL;
  664. VAR c: sCARDINAL;
  665. BEGIN
  666.  
  667.  ASSEMBLER
  668.   MOVE.W  repeat(A6), -(SP)
  669.   MOVE.W  initial(A6), -(SP)
  670.   MOVE.W  #35, -(SP)
  671.   TRAP    #14
  672.   ADDQ.L  #6, SP
  673.   MOVE.W  D0, c(A6)
  674.  END;
  675.  RETURN c;
  676.  
  677.  
  678.  
  679.  
  680. END Kbrate;
  681.  
  682. PROCEDURE Prtblk (block: ARRAY OF LOC);
  683. BEGIN
  684.  
  685.  ASSEMBLER
  686.   MOVE.L  block(A6), -(SP)
  687.   MOVE.W  #36, -(SP)
  688.   TRAP    #14
  689.   ADDQ.L  #6, SP
  690.  END;
  691.  
  692.  
  693.  
  694.  
  695. END Prtblk;
  696.  
  697. PROCEDURE Vsync;
  698. BEGIN
  699.  
  700.  ASSEMBLER
  701.   MOVE.W  #37, -(SP)
  702.   TRAP    #14
  703.   ADDQ.L  #2, SP
  704.  END;
  705.  
  706.  
  707.  
  708.  
  709. END Vsync;
  710.  
  711. PROCEDURE Supexec (code: ADDRESS);
  712. BEGIN
  713.  
  714.  ASSEMBLER
  715.   MOVE.L  code(A6), -(SP)
  716.   MOVE.W  #38, -(SP)
  717.   TRAP    #14
  718.   ADDQ.L  #6, SP
  719.  END;
  720.  
  721.  
  722.  
  723.  
  724. END Supexec;
  725.  
  726. PROCEDURE Puntaes;
  727. BEGIN
  728.  
  729.  ASSEMBLER
  730.   MOVE.W  #39, -(SP)
  731.   TRAP    #14
  732.   ADDQ.L  #2, SP
  733.  END;
  734.  
  735.  
  736.  
  737.  
  738. END Puntaes;
  739.  
  740. PROCEDURE Blitmode (flag: sINTEGER): sBITSET;
  741. VAR b: sBITSET;
  742. BEGIN
  743.  
  744.  ASSEMBLER
  745.   MOVE.W  flag(A6), -(SP)
  746.   MOVE.W  #64, -(SP)
  747.   TRAP    #14
  748.   ADDQ.L  #4, SP
  749.   MOVE.W  D0, b(A6)
  750.  END;
  751.  RETURN b;
  752.  
  753.  
  754.  
  755.  
  756. END Blitmode;
  757.  
  758. PROCEDURE Floprate (devno: sCARDINAL; newrate: sINTEGER): sINTEGER;
  759. VAR i: sINTEGER;
  760. BEGIN
  761.  
  762.  ASSEMBLER
  763.   MOVE.W  newrate(A6), -(SP)
  764.   MOVE.W  devno(A6), -(SP)
  765.   MOVE.W  #65, -(SP)
  766.   TRAP    #14
  767.   ADDQ.L  #6, SP
  768.   MOVE.W  D0, i(A6)
  769.  END;
  770.  RETURN i;
  771.  
  772.  
  773.  
  774.  
  775. END Floprate;
  776.  
  777. PROCEDURE DMAread (sec: lINTEGER; cnt: sINTEGER; buf: ADDRESS; 
  778.                    dev: sINTEGER): lINTEGER;
  779. BEGIN
  780.  
  781.  ASSEMBLER
  782.   MOVE.W  dev(A6), -(SP)
  783.   MOVE.L  buf(A6), -(SP)
  784.   MOVE.W  cnt(A6), -(SP)
  785.   MOVE.L  sec(A6), -(SP)
  786.   MOVE.W  #42, -(SP)
  787.   TRAP    #14
  788.   LEA     $E(SP), SP
  789.   MOVE.L  D0, l
  790.  END;
  791.  RETURN l;
  792.  
  793.  
  794.  
  795.  
  796. END DMAread;
  797.  
  798. PROCEDURE DMAwrite (sec: lINTEGER; cnt: sINTEGER; buf: ADDRESS;
  799.                     dev: sINTEGER): lINTEGER;
  800. BEGIN
  801.  
  802.  ASSEMBLER
  803.   MOVE.W  dev(A6), -(SP)
  804.   MOVE.L  buf(A6), -(SP)
  805.   MOVE.W  cnt(A6), -(SP)
  806.   MOVE.L  sec(A6), -(SP)
  807.   MOVE.W  #43, -(SP)
  808.   TRAP    #14
  809.   LEA     $E(SP), SP
  810.   MOVE.L  D0, l
  811.  END;
  812.  RETURN l;
  813.  
  814.  
  815.  
  816.  
  817. END DMAwrite;
  818.  
  819. PROCEDURE Bconmap (dev: sINTEGER): ADDRESS; (* ??? *)
  820. BEGIN
  821.  
  822.  ASSEMBLER
  823.   MOVE.W dev(A6), -(SP)
  824.   MOVE.W  #44, -(SP)
  825.   TRAP    #14
  826.   ADDQ.L  #4, SP
  827.   MOVE.W  D0, a
  828.  END;
  829.  RETURN a;
  830.  
  831.  
  832.  
  833.  
  834. END Bconmap;
  835.  
  836. PROCEDURE NVMaccess (mode, start, cnt: sINTEGER; buf: ADDRESS): sINTEGER;
  837. BEGIN
  838.  
  839.  ASSEMBLER
  840.   MOVE.L  buf(A6), -(SP)
  841.   MOVE.W  cnt(A6), -(SP)
  842.   MOVE.W  start(A6), -(SP)
  843.   MOVE.W  mode(A6), -(SP)
  844.   MOVE.W  #46, -(SP)
  845.   TRAP    #14
  846.   LEA     $C(SP), SP
  847.   MOVE.W  D0, i
  848.  END;
  849.  RETURN i;
  850.  
  851.  
  852.  
  853.  
  854. END NVMaccess;
  855.  
  856. PROCEDURE EsetShift (mode: sINTEGER);
  857. BEGIN
  858.  
  859.  ASSEMBLER
  860.   MOVE.W  mode(A6), -(SP)
  861.   MOVE.W  #80, -(SP)
  862.   TRAP    #14
  863.   ADDQ.L  #4, SP
  864.  END;
  865.  
  866.  
  867.  
  868.  
  869. END EsetShift;
  870.  
  871. PROCEDURE EgetShift (): sINTEGER;
  872. BEGIN
  873.  
  874.  ASSEMBLER
  875.   MOVE.W  #81, -(SP)
  876.   TRAP    #14
  877.   ADDQ.L  #2, SP
  878.   MOVE.W  D0, i
  879.  END;
  880.  RETURN i;
  881.  
  882.  
  883.  
  884.  
  885. END EgetShift;
  886.  
  887. PROCEDURE EsetBank (bank: sINTEGER): sINTEGER;
  888. BEGIN
  889.  
  890.  ASSEMBLER
  891.   MOVE.W  bank(A6), -(SP)
  892.   MOVE.W  #82, -(SP)
  893.   TRAP    #14
  894.   ADDQ.L  #4, SP
  895.   MOVE.W  D0, i
  896.  END;
  897.  RETURN i;
  898.  
  899.  
  900.  
  901.  
  902. END EsetBank;
  903.  
  904. PROCEDURE EsetColor (num, col: sINTEGER): sINTEGER;
  905. BEGIN
  906.  
  907.  ASSEMBLER
  908.   MOVE.W  col(A6), -(SP)
  909.   MOVE.W  num(A6), -(SP)
  910.   MOVE.W  #83, -(SP)
  911.   TRAP    #14
  912.   ADDQ.L  #6, SP
  913.   MOVE.W  D0, i
  914.  END;
  915.  RETURN i;
  916.  
  917.  
  918.  
  919.  
  920. END EsetColor;
  921.  
  922. PROCEDURE EsetPalette (start, cnt: sINTEGER; pal: ARRAY OF LOC): sINTEGER;
  923. BEGIN
  924.  
  925.  ASSEMBLER
  926.   MOVE.L  pal(A6), -(SP)
  927.   MOVE.W  cnt(A6), -(SP)
  928.   MOVE.W  start(A6), -(SP)
  929.   MOVE.W  #84, -(SP)
  930.   TRAP    #14
  931.   LEA     $A(SP), SP
  932.   MOVE.W  D0, i
  933.  END;
  934.  RETURN i
  935.  
  936.  
  937.  
  938.  
  939. END EsetPalette;
  940.  
  941. PROCEDURE EgetPalette (start, cnt: sINTEGER; VAR pal: ARRAY OF LOC): sINTEGER;
  942. BEGIN
  943.  
  944.  ASSEMBLER
  945.   MOVE.L  pal(A6), -(SP)
  946.   MOVE.W  cnt(A6), -(SP)
  947.   MOVE.W  start(A6), -(SP)
  948.   MOVE.W  #85, -(SP)
  949.   TRAP    #14
  950.   LEA     $A(SP), SP
  951.   MOVE.W  D0, i
  952.  END;
  953.  RETURN i;
  954.  
  955.  
  956.  
  957.  
  958. END EgetPalette;
  959.  
  960. PROCEDURE EsetGray (mode: sINTEGER): sINTEGER;
  961. BEGIN
  962.  
  963.  ASSEMBLER
  964.   MOVE.W  mode(A6), -(SP)
  965.   MOVE.W  #86, -(SP)
  966.   TRAP    #14
  967.   ADDQ.L  #4, SP
  968.   MOVE.W  D0, i
  969.  END;
  970.  RETURN i;
  971.  
  972.  
  973.  
  974.  
  975. END EsetGray;
  976.  
  977. PROCEDURE EsetSmear(mode: sINTEGER): sINTEGER;
  978. BEGIN
  979.  
  980.  ASSEMBLER
  981.   MOVE.W  mode(A6), -(SP)
  982.   MOVE.W  #87, -(SP)
  983.   TRAP    #14
  984.   ADDQ.L  #4, SP
  985.   MOVE.W  D0, i
  986.  END;
  987.  RETURN i;
  988.  
  989.  
  990.  
  991.  
  992. END EsetSmear;
  993.  
  994. END MagicXBIOS.
  995.  
  996.